import server from "../utils/request.js";/**
 * 人脸识别登录
 * @param {string} faceImageUrl - 上传到MinIO的人脸图像URL
 * @returns {Promise} - 请求响应
 */
export function faceLogin(faceImageUrl) {
  console.log('调用faceLogin API，参数名为faceImage，使用URL参数方式:', faceImageUrl);
  
  // 使用URL参数方式发送请求，适配@RequestParam注解
  return server({
    url: `/uums-server/faceLogin?faceImage=${encodeURIComponent(faceImageUrl)}`,
    method: 'post',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    }
  });
}

/**
 * 从视频元素捕获人脸图像并转换为Base64
 * @param {HTMLVideoElement} videoElement - 视频元素
 * @returns {string} - Base64编码的图像
 */
export function captureImageFromVideo(videoElement) {
  const canvas = document.createElement('canvas');
  // 减小图像尺寸，降低请求大小
  const maxWidth = 480; // 进一步减小尺寸
  const maxHeight = 360; // 进一步减小尺寸
  
  // 计算缩放比例
  let width = videoElement.videoWidth;
  let height = videoElement.videoHeight;
  
  if (width > maxWidth) {
    const ratio = maxWidth / width;
    width = maxWidth;
    height = height * ratio;
  }
  
  if (height > maxHeight) {
    const ratio = maxHeight / height;
    height = maxHeight;
    width = width * ratio;
  }
  
  canvas.width = width;
  canvas.height = height;
  
  const ctx = canvas.getContext('2d');
  ctx.drawImage(videoElement, 0, 0, width, height);
  
  // 添加时间戳水印
  ctx.font = '14px Arial';
  ctx.fillStyle = 'rgba(255,255,255,0.7)';
  ctx.fillText(`智慧社区 - ${new Date().toLocaleString()}`, 10, height - 15);
  
  // 降低图像质量以减小大小
  const dataURL = canvas.toDataURL('image/jpeg', 0.5); // 降低质量到0.5
  return dataURL.split(',')[1]; // 返回不带前缀的Base64
}

/**
 * 将图片文件转换为Base64
 * @param {File} file - 图片文件对象
 * @param {Object} options - 转换选项
 * @param {number} options.maxWidth - 最大宽度（可选）
 * @param {number} options.maxHeight - 最大高度（可选）
 * @param {number} options.quality - 图片质量，0-1之间（可选，默认0.9）
 * @param {boolean} options.withPrefix - 是否包含Data URL前缀（可选，默认false）
 * @returns {Promise<string>} - Promise，解析为Base64编码的图像
 */
export function imageToBase64(file, options = {}) {
  return new Promise((resolve, reject) => {
    // 检查文件类型
    if (!file || !file.type.match(/^image\/(jpeg|png|gif|bmp|webp)$/)) {
      reject(new Error('请提供有效的图片文件'));
      return;
    }

    const reader = new FileReader();
    
    reader.onload = (e) => {
      const img = new Image();
      
      img.onload = () => {
        // 创建canvas
        const canvas = document.createElement('canvas');
        
        // 计算尺寸，如果提供了最大尺寸限制
        let width = img.width;
        let height = img.height;
        
        if (options.maxWidth && width > options.maxWidth) {
          const ratio = options.maxWidth / width;
          width = options.maxWidth;
          height = height * ratio;
        }
        
        if (options.maxHeight && height > options.maxHeight) {
          const ratio = options.maxHeight / height;
          height = options.maxHeight;
          width = width * ratio;
        }
        
        // 设置canvas尺寸
        canvas.width = width;
        canvas.height = height;
        
        // 绘制图像
        const ctx = canvas.getContext('2d');
        ctx.drawImage(img, 0, 0, width, height);
        
        // 转换为Base64
        const quality = options.quality !== undefined ? options.quality : 0.9;
        const dataURL = canvas.toDataURL(file.type, quality);
        
        // 根据选项决定是否返回带前缀的Base64
        if (options.withPrefix) {
          resolve(dataURL);
        } else {
          resolve(dataURL.split(',')[1]);
        }
      };
      
      img.onerror = () => {
        reject(new Error('图片加载失败'));
      };
      
      // 设置图片源
      img.src = e.target.result;
    };
    
    reader.onerror = () => {
      reject(new Error('文件读取失败'));
    };
    
    // 读取文件
    reader.readAsDataURL(file);
  });
}

/**
 * 将Base64编码的图像转换为Blob对象
 * @param {string} base64 - Base64编码的图像（可以带或不带Data URL前缀）
 * @param {string} mimeType - MIME类型（可选，默认为'image/jpeg'）
 * @returns {Blob} - Blob对象
 */
export function base64ToBlob(base64, mimeType = 'image/jpeg') {
  // 如果base64包含前缀，去除前缀
  const base64Data = base64.includes(',') ? base64.split(',')[1] : base64;
  
  // 解码base64
  const byteCharacters = atob(base64Data);
  const byteArrays = [];
  
  // 将解码后的字符串分割成多个块
  for (let offset = 0; offset < byteCharacters.length; offset += 512) {
    const slice = byteCharacters.slice(offset, offset + 512);
    
    const byteNumbers = new Array(slice.length);
    for (let i = 0; i < slice.length; i++) {
      byteNumbers[i] = slice.charCodeAt(i);
    }
    
    const byteArray = new Uint8Array(byteNumbers);
    byteArrays.push(byteArray);
  }
  
  // 创建Blob对象
  return new Blob(byteArrays, { type: mimeType });
}

/**
 * 压缩Base64图像
 * @param {string} base64Image - Base64编码的图像
 * @param {number} quality - 压缩质量（0-1之间）
 * @param {number} maxSize - 最大尺寸（像素）
 * @returns {Promise<string>} - 压缩后的Base64编码图像
 */
export function compressBase64Image(base64Image, quality = 0.5, maxSize = 320) {
  return new Promise((resolve, reject) => {
    try {
      // 如果图像数据已经足够小，直接返回
      if (base64Image.length < 50000) { // 小于约50KB
        resolve(base64Image);
        return;
      }
      
      const img = new Image();
      
      img.onload = () => {
        // 创建一个离屏canvas来压缩图像
        const canvas = document.createElement('canvas');
        
        // 设置最大尺寸
        let width = img.width;
        let height = img.height;
        
        // 计算缩放比例
        if (width > height && width > maxSize) {
          height = Math.round((height * maxSize) / width);
          width = maxSize;
        } else if (height > maxSize) {
          width = Math.round((width * maxSize) / height);
          height = maxSize;
        }
        
        // 设置canvas尺寸
        canvas.width = width;
        canvas.height = height;
        
        // 绘制并压缩图像
        const ctx = canvas.getContext('2d');
        ctx.drawImage(img, 0, 0, width, height);
        
        // 返回压缩后的Base64（不带前缀）
        const compressedBase64 = canvas.toDataURL('image/jpeg', quality).split(',')[1];
        resolve(compressedBase64);
      };
      
      img.onerror = () => {
        reject(new Error('图像压缩失败：无法加载图像'));
      };
      
      // 设置图像源
      img.src = 'data:image/jpeg;base64,' + base64Image;
      
    } catch (error) {
      console.error('图像压缩失败:', error);
      resolve(base64Image); // 出错时返回原始图像
    }
  });
}

// 导入uploadImg函数
import { uploadImg } from './owner';

/**
 * 发送人脸识别请求
 * @param {string} faceImage - Base64编码的人脸图像
 * @param {number} lockId - 锁的ID（1、2、3或4）
 * @returns {Promise} - 请求响应
 */
export async function faceRecognition(faceImage, lockId = 1) {
  try {
    // 压缩图像以减小请求大小
    const compressedImage = await compressBase64Image(faceImage);
    console.log('原始图像大小:', Math.round(faceImage.length / 1024), 'KB');
    console.log('压缩后图像大小:', Math.round(compressedImage.length / 1024), 'KB');
    
    // 将Base64转换为Blob对象
    const imageBlob = base64ToBlob(compressedImage);
    console.log('准备上传图片到MinIO...');
    
    // 上传图片到MinIO，获取URL
    const uploadResponse = await uploadImg(imageBlob);
    console.log('图片上传成功:', uploadResponse);
    
    if (!uploadResponse.data || !uploadResponse.data.data) {
      throw new Error('图片上传失败，未获取到URL');
    }
    
    const imageUrl = uploadResponse.data.data;
    console.log('获取到图片URL:', imageUrl);
    
    // 调用人脸识别API
    console.log('发送人脸识别请求...');
    const response = await server({
      url: `/opencv-server/face/unlock?lockId=${lockId}`,
      method: 'post',
      data: {
        imageUrl
      },
      headers: {
        'Content-Type': 'application/json'
      }
    });
    
    console.log('人脸识别响应:', response);
    return response;
  } catch (error) {
    console.error('人脸识别请求失败:', error);
    throw error;
  }
}

// 导出其他函数
export {
//   captureImageFromVideo,
//   imageToBase64
  // base64ToBlob 已在函数定义处导出，此处不再重复导出
  // compressBase64Image 已在函数定义处导出，此处不再重复导出
  // faceRecognition 已在函数定义处导出，此处不再重复导出
};
    